import moment from 'moment';

// moment.locale('en');
const quarterlyList = ['03-31', '06-30', '09-30', '12-31']

/**
 * 将 ['name', 'age'] =>  [{value: 0, label: 'name'}, {value: 1, label: 'age'}]
 * */
export const addkey = (arr) => {
  return arr.map((val, key) => {
    let item = {}
    item.value = key.toString()
    item.label = val
    return item
  })
}

// 将 ['name', 'age'] [1, 2] =>  [{value: 1, label: 'name'}, {value: 1, label: 'age'}]
export const combineArr = (arr1, arr2) => {
  let arr = []
  for (let i = 0; i < arr1.length; i++) {
    let item = {}
    item.label = arr1[i]
    item.value = arr2[i]
    arr.push(item)
  }
  return arr
}

// let THIS_DAY = moment(new Date()).format('YYYY-MM-DD');
// let PRE_ONE_WEEK = moment(new Date()).subtract(7, 'days').format('YYYY-MM-DD'); // 一周前
// let PRE_ONE_MONTH = moment(new Date()).subtract(1, 'months').format('YYYY-MM-DD'); // 一月前
// let PRE_THREE_MONTH = moment(new Date()).subtract(3, 'months').format('YYYY-MM-DD'); // 三月前
// let PRE_SIX_MONTH = moment(new Date()).subtract(6, 'months').format('YYYY-MM-DD'); // 六月前
// let PRE_ONE_YEAR = moment(new Date()).subtract(1, 'years').format('YYYY-MM-DD'); // 一年前
// let PRE_TWO_YEAR = moment(new Date()).subtract(2, 'years').format('YYYY-MM-DD'); // 两年前
// let PRE_THREE_YEAR = moment(new Date()).subtract(3, 'years').format('YYYY-MM-DD'); // 三年前
// let BEGIN_YEAR = moment(new Date()).startOf('years').format('YYYY-MM-DD'); // 本年初
// let BEGIN_MONTH = moment(new Date()).startOf('months').format('YYYY-MM-DD'); // 本月初
// export const BEGIN_WEEK = moment().subtract((moment(new Date()).format('E')) - 1, 'days').format('YYYY-MM-DD'); // 本周一


/**
 * 获取之前某个时间点的日期
 * days 具体时间点，如 1,2
 * type 类型,如 year, months
 * 案例 getPreDay（3,'months'） 获取三个月前的日期
 * */
export const getPreDay = (days, type) => {
  return moment(new Date()).subtract(days, type).format('YYYY-MM-DD');
}

/**
 * 获取月初或年初的日期
 * type 类型,如 year, months
 * 案例 getStartDay（'years'） 获取本年初的日期
 * */
export const getStartDay = (type) => {
  return moment(new Date()).startOf(type).format('YYYY-MM-DD');
}

/**
 * 获取本周一的日期
 * */
export const getMonday = () => {
  return moment().subtract((moment(new Date()).format('E')) - 1, 'days').format('YYYY-MM-DD');
}

/**
 * 获取当年所在季度的最后日期
 * */
export const getCurrentQuarter = () => {
  let currentQuarter = moment().quarter() // 当前是第几季度
  return moment().year() + "-" + quarterlyList[currentQuarter - 1]
}

/**
 * 格式化时间
 * */
export const formatter = (date) => {
  return moment(date).format('YYYY-MM-DD')
}

/**
 * 深度克隆
 * */
export const deepClone = (obj) => {
  function isClass(o) {  // 判断obj的类型
    if (o === null) return "Null";
    if (o === undefined) return "Undefined";
    return Object.prototype.toString.call(o).slice(8, -1);
  }

  var result, oClass = isClass(obj);//确定result的类型
  if (oClass === "Object") {
    result = {};
  } else if (oClass === "Array") {
    result = [];
  } else {
    return obj;
  }
  for (let key in obj) {
    var copy = obj[key];
    if (isClass(copy) == "Object") {
      result[key] = deepClone(copy);//递归调用
    } else if (isClass(copy) == "Array") {
      result[key] = deepClone(copy);
    } else {
      result[key] = obj[key];
    }
  }
  return result;
}

/**
 * 处理选择多个时间段,如2018，2020，[1,2]  => [2018-1, 2018-2, 2019-1, 2019-2, 2020-1, 2020-2]
 * */
export const handleSomeTime = ({ leftValue, rightValue, checked }) => {
  let left = Number(leftValue)
  let right = Number(rightValue)
  let arr = []
  for (let i = 0; i <= right - left; i++) {
    checked.forEach(item => {
      arr.push(`${left + i}-${item}`)
    })
  }
  return arr.sort()
}

/**
 * 获取开始到截止的时间段 ,如2018，2020=> [2018, 2019, 2020]
 * */
export const handleSomeYear = ({ leftValue, rightValue }) => {
  let left = Number(leftValue)
  let right = Number(rightValue)
  let arr = []
  for (let i = 0; i <= right - left; i++) {
    arr.push(`${left + i}`)
  }
  return arr
}

/**
 * 校验值是否为<=1000000的整数
 * */
export const checkNumber = (value) => {
  if (typeof Number(value) != 'number' || (!Number.isInteger(Number(value)) ||  value > 1000000)) {
    return false
  }
  return true
}

/**
 * 上个季度的最后一天
 * */
export const getLastQuarter = () => {
  // let date = []
  // let start = moment().quarter(moment().quarter() - 1).startOf('quarter').format('YYYY-MM-DD')
  return moment().quarter(moment().quarter() - 1).endOf('quarter').format('YYYY-MM-DD')
  // date.push(start)
  // date.push(end)
  // return date
}

/**
   * @param {Object} json
   * @param {Object} type： 默认不传 ==>全部小写;传1 ==>全部大写;传2 ==>首字母大写
   * 将json的key值进行大小写转换
   */
export const jsonKeysToCase = (json, type) => {
  if (typeof json == 'object') {
    var tempJson = JSON.parse(JSON.stringify(json));
    toCase(tempJson);
    return tempJson;
  } else {
    return json;
  }

  function toCase(json) {
    if (typeof json == 'object') {
      if (Array.isArray(json)) {
        json.forEach(function (item) {
          toCase(item);
        })
      } else {
        for (var key in json) {
          var item = json[key];
          if (typeof item == 'object') {
            toCase(item);
          }
          delete (json[key]);
          switch (type) {
            case 1:
              //key值全部大写
              json[key.toLocaleUpperCase()] = item;
              break;
            case 2:
              //key值首字母大写，其余小写
              json[key.substring(0, 1).toLocaleUpperCase() + key.substring(1).toLocaleLowerCase()] = item;
              break;
            default:
              //默认key值全部小写
              json[key.toLocaleLowerCase()] = item;
              break;
          }
        }
      }
    }
  }
}

/**
 * @param {Object} json
 * 将json的key和value进行大小写转换
 */
export const jsonToCase = (json, type) => {
  if (typeof json == 'object') {
    var tempJson = JSON.parse(JSON.stringify(json));
    toCase(tempJson);
    return tempJson;
  } else {
    return json;
  }
  function toCase(json) {
    if (typeof json == 'object') {
      if (Array.isArray(json)) {
        json.forEach(function (item) {
          toCase(item);
        })
      } else {
        for (var key in json) {
          var item = json[key], value = '';
          if (typeof item == 'object') {
            toCase(item);
          }
          if (!(typeof item == 'object') && (typeof item == 'string')) {
            value = item.toLowerCase()
          } else value = item
          delete (json[key]);
          json[key.toLocaleLowerCase()] = value;
        }
      }
    }
  }
}

/**
 * 删除数据中指定元素
 */
export const removeList = (arr, val)=> {
  arr.forEach((item,key) => {
    if (item == val) {
      arr.splice(key,1)
    }
  })
}

/**
 * 判断两个对象的值是否相等
 */
export const objectsEqual = (obj, obj1)=> {
  return JSON.stringify(obj) === JSON.stringify(obj1)
}

/**
 * 判断前后两次的IndicatorExps值是否相等
 */
export const IndicatorExpsEqual = (newArr, oldArr) => {
  let differArr = []
  newArr.forEach(item => {
    let common = oldArr.some(val => item.Alias === val.Alias)
    if (common) {
      oldArr.forEach(val => {
        if (item.Alias === val.Alias) {
          if (JSON.stringify(item) != JSON.stringify(val)) { // 前后指标不相同
            differArr.push(item)
          }
        }
      })
    } else {
      differArr.push(item)
    }
  })
  return differArr
}

/**
 * 判断参数类型
 */
export const paramsType = (type) => {
  if (typeof type !== 'string') return false
  const numberList = ['DOUBLE', 'INT', 'LONG', 'FLOAT']
  if (numberList.includes(type.toUpperCase())) {
   return 'number'
  } else if (type == 'DATE') {
    return 'date'
  } else {
    return 'string'
  }
}


/**
 * 处理条件选股的单位Unit
 */
export const handleUnit = (arr) => {
  // let titleList = ['[交易日期]:2020-11-24', '[交易日期]:2020-11-24', '[单位]:元']
  arr.splice(0,1) // 删除表头
  let index = ''
  let unit = ''
  arr.forEach((item,key) => {
    if (item.includes('单位')) {
      index = key
      unit = item.split(':')[1]
      arr.splice(index,1)
    }
  })
  let paramtext = arr.join().replace(/<p>|<\/p>|\[|\]/g, '')
  return {unit, paramtext}
}

/**
 * 求百分比
 */
export const GetPercent = (num, total) => {
  /// <summary>
  /// 求百分比
  /// </summary>
  /// <param name="num">当前数</param>
  /// <param name="total">总数</param>
  num = parseFloat(num);
  total = parseFloat(total);
  if (isNaN(num) || isNaN(total)) {
    return "-";
  }
  return total <= 0 ? "0%" : (Math.round(num / total * 10000) / 100.00)+"%";
}

/**
 * format 我的模板数据结构
 */
export const formatPriviteData = (arr) => {
  if (!Array.isArray(arr) || arr.length == 0) {
    return arr
  }
  arr.forEach(item => {
    item.label = item.name
    if(item.child && item.child.length > 0) {
      item.children = formatPriviteData(item.child)
      delete item.child
    } else if (item.child && item.child.length == 0) {
      delete item.child
    }
  })
  return arr
}

/**
 * 唯一值
 */
export const getUUID = () => {
  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
    var r = Math.random()*16|0, v = c == 'x' ? r : (r&0x3|0x8);
    return v.toString(16);
  });
}


/**
 * 校验一个字符串是Sheet+n
 */
export const checkSheetNum = (str)=> {
  return /^Sheet[1-9]\d*$/.test(str)
}

/**
 * @function 查找一个字符串中符合（#+数字）的字符
 * @param {string} str 需进行匹配的字符串
 * @return {array} 符合的字符串集合
 */
export const checkStr = (str)=> {
  return str.match(/#[1-9]\d*/g)
}

/**
 * @function 将英文的() 替换成中文的（）
 * @param {string} str 需进行匹配的字符串
 * @return {string} 替换后的字符串
 */
export const replaceBrackets = (str)=> {
  // return str.replace(/\(/g, '（').replace(/\)/g, '）')
  // return str.replace(/\(/g, '（').replace(/\)/g, '）')
  return str.replace(/\(|\)/g, '\\$&')
}

/**
 * @function 将中文的（）替换成英文的()
 * @param {string} str 需进行匹配的字符串
 * @return {string} 替换后的字符串
 */
export const bracketsReplace = (str)=> {
  return str.replace(/（/g, '(').replace(/）/g, ')')
}

/**
 * 过滤我的模板，根据点击的id找到该点所在的层级,并且删除该id对应的数据
 */
export const filterMyTemplate = (list, id) => {
  let arr = []
  for (let i = 0; i < list.length; i++) {
    if (list[i].id === id) {
      list.splice(i, 1)
      arr = list
      break
    } else if (list[i].children && list[i].children.length > 0) {
      arr = filterMyTemplate(list[i].children, id)
    }
  }
  return arr
}

/**
 * 冻结表格
 */
export const freezeList = (list) => {
  Object.freeze(list);
  list.forEach(item => {
    Object.freeze(item); // 深层冻结，冻结每一条数据
  });
  return list
}

/**
 * @function 字符串指定位置插入字符
 * @param {string} source 初始字符串
 * @param {number} start 插入的位置
 * @param {string} newStr 要插入的字符串
 * @return {string} 新的字符串
 */
export const insertStr = (source, start, newStr) => {
  return source.slice(0, start) + newStr + source.slice(start);
}



/**
 * @function 指标交易日期/截止日期处理
 * @param {string} str 日期标识
 * 
 */
export const handleDate = (str) => {
  let date = '';
  switch(str){
    case 'NewestTradingDate': //最新
      date = formatter(new Date());
      break;
    case 'OneYear': //1年前
      date = getPreDay(1, 'years');
      break;
    case 'TwoYear': //2年前
      date = getPreDay(2, 'years');
      break;
    case 'OneWeek': //1周前
      date = getPreDay(7, 'days');
      break;
    case 'ThisBeginOfYear': //本年初
      date = getStartDay('years');
      break;
    case 'OneMonth': //1月前
      date = getPreDay(1, 'months');
      break;
    case 'ThisBeginOfMonth': //本月初
      date = getStartDay('months');
      break;
    case 'ThreeMonths': //3月前
      date = getPreDay(3,'months');
      break;
    case 'ThisMonday'://本周一
      date = getMonday();
      break;
    case 'HalfYear': //6月前
      date = getPreDay(6, 'months');
      break;
    default:
      date = '';
      break;
  }
  return date
}
